const fs = require('fs');
const path = require('path');

/**
 * 分析构造函数原型方法和属性的注释情况
 * @param {string} constructorName 构造函数名称
 * @param {string} filePath 文件路径，默认为 'mxgraph/mxClient.js'
 * @returns {Object} 包含原型属性/方法名及其注释状态的对象
 */
function analyzeConstructor(constructorName, filePath = 'mxgraph/mxClient.js') {
    try {
        // 读取文件内容
        const fullPath = path.resolve(filePath);
        const content = fs.readFileSync(fullPath, 'utf8');

        // 按行分割内容
        const lines = content.split('\n');

        // 结果对象
        const result = {};

        // 匹配原型模式：constructorName.prototype.xxx = 
        const prototypePattern = new RegExp(`^\\s*${constructorName}\\.prototype\\.([^\\s=]+)\\s*=`, 'i');

        // 遍历每一行，寻找原型定义
        for (let i = 0; i < lines.length; i++) {
            const line = lines[i];
            const match = line.match(prototypePattern);

            if (match) {
                const propertyName = match[1];

                // 检查前面的行是否有注释
                let hasComment = false;

                // 向前查找注释（最多查找5行）
                for (let j = i - 1; j >= Math.max(0, i - 5); j--) {
                    const prevLine = lines[j].trim();

                    // 如果是空行，继续查找
                    if (prevLine === '') {
                        continue;
                    }

                    // 如果找到注释（单行注释或多行注释的结束）
                    if (prevLine.startsWith('//') ||
                        prevLine.startsWith('*') ||
                        prevLine.endsWith('*/') ||
                        prevLine.startsWith('/**')) {
                        hasComment = true;
                        break;
                    }

                    // 如果遇到其他代码，停止查找
                    if (prevLine && !prevLine.startsWith('//') && !prevLine.startsWith('*') && !prevLine.includes('*/')) {
                        break;
                    }
                }

                result[propertyName] = hasComment;
            }
        }

        return result;

    } catch (error) {
        console.error('分析过程中出错:', error.message);
        return {};
    }
}

/**
 * 获取文件中所有的构造函数名称
 * @param {string} filePath 文件路径
 * @returns {Array} 构造函数名称数组
 */
function getAllConstructors(filePath = 'mxgraph/mxClient.js') {
    try {
        const fullPath = path.resolve(filePath);
        const content = fs.readFileSync(fullPath, 'utf8');
        const lines = content.split('\n');

        const constructors = new Set();

        // 匹配函数定义：function mxFunctionName(
        const functionPattern = /^\s*function\s+(mx[a-zA-Z0-9_]*)\s*\(/;

        for (const line of lines) {
            const match = line.match(functionPattern);
            if (match) {
                constructors.add(match[1]);
            }
        }

        return Array.from(constructors).sort();

    } catch (error) {
        console.error('获取构造函数列表时出错:', error.message);
        return [];
    }
}

/**
 * 命令行调用方式
 */
function main() {
    const args = process.argv.slice(2);

    if (args.length === 0) {
        console.log('用法: node analyzeConstructor.js <构造函数名> [文件路径]');
        console.log('或者: node analyzeConstructor.js --list [文件路径]  (列出所有构造函数)');
        console.log('');
        console.log('示例:');
        console.log('  node analyzeConstructor.js mxDictionary');
        console.log('  node analyzeConstructor.js mxPoint mxgraph/mxClient.js');
        console.log('  node analyzeConstructor.js --list');
        return;
    }

    if (args[0] === '--list') {
        const filePath = args[1] || 'mxgraph/mxClient.js';
        const constructors = getAllConstructors(filePath);

        console.log(`在 ${filePath} 中找到的构造函数:`);
        console.log('='.repeat(50));
        constructors.forEach((name, index) => {
            console.log(`${index + 1}. ${name}`);
        });
        console.log(`\n总计: ${constructors.length} 个构造函数`);
        return;
    }

    const constructorName = args[0];
    const filePath = args[1] || 'mxgraph/mxClient.js';

    console.log(`分析构造函数: ${constructorName}`);
    console.log(`文件路径: ${filePath}`);
    console.log('='.repeat(50));

    const result = analyzeConstructor(constructorName, filePath);

    if (Object.keys(result).length === 0) {
        console.log(`未找到构造函数 "${constructorName}" 的原型定义`);
        return;
    }

    // 统计信息
    const totalProperties = Object.keys(result).length;
    const withComments = Object.values(result).filter(Boolean).length;
    const withoutComments = totalProperties - withComments;

    console.log(`原型属性/方法分析结果:`);
    console.log('');

    // 显示有注释的
    console.log('✅ 有注释的属性/方法:');
    Object.entries(result)
        .filter(([, hasComment]) => hasComment)
        .forEach(([name]) => {
            console.log(`  - ${name}`);
        });

    console.log('');

    // 显示没有注释的
    console.log('❌ 没有注释的属性/方法:');
    Object.entries(result)
        .filter(([, hasComment]) => !hasComment)
        .forEach(([name]) => {
            console.log(`  - ${name}`);
        });

    console.log('');
    console.log('统计信息:');
    console.log(`  总计: ${totalProperties} 个属性/方法`);
    console.log(`  有注释: ${withComments} 个 (${(withComments/totalProperties*100).toFixed(1)}%)`);
    console.log(`  无注释: ${withoutComments} 个 (${(withoutComments/totalProperties*100).toFixed(1)}%)`);

    // 返回结果对象（如果被其他模块引用）
    return result;
}

// 如果直接运行此脚本
if (require.main === module) {
    main();
}

// 导出函数供其他模块使用
module.exports = {
    analyzeConstructor,
    getAllConstructors
};